import axios from "axios";
import router from "@/router";

// 基础配置
const BASE_URL = "http://127.0.0.1:8888";
const service = axios.create({
  baseURL: BASE_URL,
  timeout: 10000,
});

// 请求拦截器：添加Token
service.interceptors.request.use(
  (config) => {
    console.log(`[请求] ${config.method.toUpperCase()} ${config.url}`);
    try {
      const token = localStorage.getItem("token");
      const tokenHead = localStorage.getItem("token_head") || "Bearer ";
      if (token) {
        config.headers["Authorization"] = tokenHead + token;
      }
    } catch (e) {
      console.error("[请求拦截器] LocalStorage操作失败:", e);
    }
    return config;
  },
  (error) => {
    console.error("[请求初始化错误]", error);
    return Promise.reject(new Error("请求参数错误，请检查"));
  }
);

// Token刷新相关变量
let isRefreshing = false;
let requests = [];

// 响应拦截器：统一处理所有响应
service.interceptors.response.use(
  async (response) => {
    console.log(
      `[响应] ${response.config.method.toUpperCase()} ${response.config.url}`,
      "HTTP状态码:",
      response.status
    );
    // 解析统一响应格式（兼容response.data为undefined的情况）
    const responseData = response.data || {};
    const { status, message, data } = responseData;
    console.log("[响应数据]", { status, message, data });

    const successCode = 0; // 业务成功状态码
    const unloginCode = 11008; // 未登录/Token失效状态码

    // 业务成功：返回完整响应数据（或仅data，根据前端需求调整）
    // if (status === successCode) {
    //   console.log("[业务成功]", message || "操作成功");
    //   return responseData; // 保持与后台格式一致，便于前端获取message等信息
    // }

    // 处理未登录/Token失效
    if (status === unloginCode) {
      console.warn("[认证失效] 未登录或Token已过期，尝试刷新Token");

      const originalRequest = response.config;

      // 防止重复刷新和重试
      if (!originalRequest._retry) {
        if (!isRefreshing) {
          isRefreshing = true;
          let refreshToken;

          // 获取refresh_token
          try {
            refreshToken = localStorage.getItem("refresh_token");
            console.log(
              "[Token刷新] 获取refresh_token:",
              refreshToken ? "存在" : "不存在"
            );
          } catch (e) {
            isRefreshing = false;
            console.error("[Token刷新] 读取refresh_token失败:", e);
            return Promise.reject(new Error("本地存储异常，请重新登录"));
          }

          // 无refresh_token：直接跳转登录
          if (!refreshToken) {
            isRefreshing = false;
            clearAuthData();
            router.push("/login");
            return Promise.reject(new Error(message || "请先登录")); // 优先使用后台消息
          }

          try {
            // 发起刷新请求（使用原生axios避免拦截器循环）
            console.log("[Token刷新] 发起刷新请求");
            const refreshRes = await axios.post(
              `${BASE_URL}/oauth/token`,
              new URLSearchParams({
                grant_type: "refresh_token",
                refresh_token: refreshToken,
                client_id: "client-h5",
                client_secret: "123456",
              }),
              {
                headers: {
                  "Content-Type": "application/x-www-form-urlencoded",
                },
                timeout: 10000,
              }
            );

            // 验证刷新响应（遵循后台统一格式：status、data）
            const refreshResData = refreshRes.data || {};
            const { status: refreshStatus, data: refreshData } = refreshResData;
            if (
              refreshStatus !== successCode || // 用status判断刷新是否成功
              !refreshData?.token ||
              !refreshData?.refreshToken
            ) {
              throw new Error(
                refreshResData.message || "刷新Token失败，响应格式不正确"
              );
            }

            // 存储新Token
            try {
              localStorage.setItem("token", refreshData.token);
              localStorage.setItem("refresh_token", refreshData.refreshToken);
              localStorage.setItem(
                "token_head",
                refreshData.tokenHead || "Bearer "
              );
              console.log("[Token刷新] 新Token存储成功");
            } catch (e) {
              console.error("[Token刷新] 存储新Token失败:", e);
              throw e;
            }

            // 重试缓存的请求
            isRefreshing = false;
            requests.forEach((cb) => cb()); // 执行缓存的回调
            requests = [];

            // 重试当前请求
            originalRequest._retry = true;
            const tokenHead = localStorage.getItem("token_head") || "Bearer ";
            originalRequest.headers[
              "Authorization"
            ] = `${tokenHead}${refreshData.token}`;
            console.log("[Token刷新] 重试原请求:", originalRequest.url);
            return service(originalRequest);
          } catch (e) {
            // 刷新失败处理
            isRefreshing = false;
            requests = []; // 清空缓存请求，避免内存泄漏
            clearAuthData();
            router.push("/login");
            console.error("[Token刷新] 刷新失败:", e.message);
            return Promise.reject(
              new Error(e.message || "登录已过期，请重新登录")
            );
          }
        } else {
          // 并发请求：等待刷新完成后重试
          return new Promise((resolve) => {
            requests.push(() => {
              const tokenHead = localStorage.getItem("token_head") || "Bearer ";
              const token = localStorage.getItem("token");
              originalRequest.headers["Authorization"] = `${tokenHead}${token}`;
              originalRequest._retry = true;
              resolve(service(originalRequest));
            });
          });
        }
      }
    }

    // 交给页面来处理
    return responseData;

    // 其他业务错误（非成功也非未登录）
    // console.warn(
    //   `[业务错误] 错误码: ${status}, 消息: ${message || "未知错误"}`
    // );
    // return Promise.reject(
    //   new Error(message || `业务错误（状态码：${status}）`)
    // );
  },
  (error) => {
    // 处理系统级错误（服务挂了、网络错误、超时等）
    console.group("[系统错误]");
    console.log("错误信息:", error.message);
    console.log("请求配置:", error.config);
    console.groupEnd();

    // 网络错误（无响应）
    if (!error.response) {
      return Promise.reject(new Error("服务暂时不可用，请稍后再试"));
    }

    // 超时错误
    if (error.code === "ECONNABORTED") {
      return Promise.reject(new Error("请求超时，请稍后重试"));
    }

    // 其他系统错误（如HTTP 5xx）
    return Promise.reject(
      new Error(`系统错误: ${error.response.status}（${error.message}）`)
    );
  }
);

// 清除认证数据工具函数
function clearAuthData() {
  try {
    localStorage.removeItem("token");
    localStorage.removeItem("refresh_token");
    localStorage.removeItem("token_head");
    console.log("[清除认证数据] 成功");
  } catch (e) {
    console.error("[清除认证数据] 失败:", e);
  }
}

// 导出请求方法
export function get(url, params, config = {}) {
  return service.get(url, { params, ...config });
}

export function post(url, data, config = {}) {
  return service.post(url, data, config);
}

export default service;
